const { User } = require("../db");
const jwt = require('jsonwebtoken');
const { secretKey } = require('../config/config');
const { Op } = require('sequelize');
const multer = require('multer');
const xlsx = require('xlsx');

// 登录功能（保持不变）
exports.login = async (req, res) => {
    const { username, password } = req.body;
    if (username && password) {
        try {
            const tempUser = await User.findOne({ where: { username: username } });
            if (tempUser) {
                if (tempUser.dataValues.password === password) {
                    const tokenStr = jwt.sign({ id: tempUser.dataValues.id }, secretKey, { expiresIn: '86400s' });
                    res.send({
                        status: 200,
                        message: '登录成功！',
                        user: { ...tempUser.dataValues },
                        token: tokenStr,
                    });
                } else {
                    res.send({
                        status: 500,
                        message: '密码错误！'
                    });
                }
            } else {
                res.send({
                    status: 404,
                    message: '用户不存在！'
                });
            }
        } catch (err) {
            console.log(err);
            res.status(500).send('Failed to login');
        }
    }
};

// 注册功能
exports.register = async (req, res) => {
    const { username, password, phone, is_counselor = false, is_assistantn = false, is_admin = false, introduction = '' } = req.body;
    if (username && password && phone) {
        try {
            const tempUser = await User.findOne({ where: { username: username } });
            if (tempUser) {
                res.send({
                    status: 304,
                    message: '用户已存在！'
                });
            } else {
                const newUser = await User.create({
                    username: username,
                    password: password,
                    phone: phone,
                    is_counselor: is_counselor,
                    is_assistantn: is_assistantn, 
                    is_admin: is_admin,
                    introduction: introduction
                });
                if (newUser) {
                    res.send({
                        status: 200,
                        message: '注册成功！',
                    });
                } else {
                    res.send({
                        status: 500,
                        message: '注册失败！',
                    });
                }
            }
        } catch (err) {
            console.log(err);
            res.status(500).send('Failed to register');
        }
    } else {
        res.status(400).send({
            status: 400,
            message: '用户名、密码和电话号码为必填项！'
        });
    }
};

// 获取所有用户（包含自我介绍）- 允许未登录访问
exports.getAllUsers = async (req, res) => {
    try {
        // 添加默认值处理
        const { 
            username = '', 
            is_counselor = null, 
            is_assistantn = null, 
            is_admin = null, 
            page = 1, 
            pageSize = 10 
        } = req.body; 

        // 验证分页参数
        const pageNum = parseInt(page);
        const size = parseInt(pageSize);

        if (isNaN(pageNum) || pageNum < 1) {
            return res.status(400).json({
                status: 400,
                message: '无效的页码参数，页码必须为大于等于 1 的整数'
            });
        }

        if (isNaN(size) || size < 1) {
            return res.status(400).json({
                status: 400,
                message: '无效的每页数量参数，每页数量必须为大于等于 1 的整数'
            });
        }

        const whereCondition = {
            username: {
                [Op.like]: `%${username}%`
            }
        };

        if (is_counselor !== null) {
            whereCondition.is_counselor = is_counselor === 'true';
        }

        if (is_assistantn !== null) {
            whereCondition.is_assistantn = is_assistantn === 'true';
        }

        if (is_admin !== null) {
            whereCondition.is_admin = is_admin === 'true';
        }

        const users = await User.findAndCountAll({
            where: whereCondition,
            attributes: { exclude: ['password'] }, // 排除密码字段
            offset: (pageNum - 1) * size,
            limit: size
        });

        res.send({
            status: 200,
            message: '获取用户列表成功！',
            data: {
                users: users.rows,
                total: users.count,
                page: pageNum,
                pageSize: size,
                totalPages: Math.ceil(users.count / size)
            }
        });
    } catch (err) {
        console.log(err);
        res.status(500).json({
            status: 500,
            message: '获取用户列表失败',
            error: err.message
        });
    }
};
// 获取单个用户信息（包含自我介绍）- 允许未登录访问
exports.getUserById = async (req, res) => {
    const { id } = req.body;
    try {
        const user = await User.findOne({
            where: { id },
            attributes: { exclude: ['password'] } // 排除密码字段
        });
        
        if (user) {
            res.send({
                status: 200,
                message: '获取用户信息成功！',
                data: user
            });
        } else {
            res.status(404).json({
                status: 404,
                message: '用户不存在！'
            });
        }
    } catch (err) {
        console.log(err);
        res.status(500).json({
            status: 500,
            message: '获取用户信息失败',
            error: err.message
        });
    }
};

// 删除用户 - 需要管理员权限
exports.deleteUser = async (req, res) => {
    const { id } = req.body; // 从URL参数获取用户ID
    
    try {
        const result = await User.destroy({
            where: { id }
        });
        
        if (result) {
            res.json({
                status: 200,
                message: '删除用户成功！'
            });
        } else {
            res.status(404).json({
                status: 404,
                message: '用户不存在！'
            });
        }
    } catch (err) {
        console.log(err);
        res.status(500).json({
            status: 500,
            message: '删除用户失败',
            error: err.message
        });
    }
};
// 更新用户信息 - 需要登录且只能更新自己的信息或管理员
exports.updateUser = async (req, res) => {
    const { id } = req.body;
    const { username, password, name, phone, email, id_card, avatar, is_counselor, is_assistantn, is_admin, introduction, counselor_free_time } = req.body;
    
    // 检查权限：只能修改自己的信息，除非是管理员
    if (req.user.id!== parseInt(id) &&!req.user.is_admin) {
        return res.status(403).json({
            status: 403,
            message: '无权修改其他用户信息！'
        });
    }
    
    try {
        const updateData = {
            username,
            password,
            name,
            phone,
            email,
            id_card,
            avatar,
            introduction,
            counselor_free_time
        };
        
        // 只有管理员可以修改角色权限
        if (req.user.is_admin) {
            updateData.is_counselor = is_counselor;
            updateData.is_assistantn = is_assistantn;
            updateData.is_admin = is_admin;
        }
        
        // 移除undefined的字段
        Object.keys(updateData).forEach(key => updateData[key] === undefined && delete updateData[key]);
        
        const [affectedCount] = await User.update(updateData, {
            where: { id }
        });
        
        if (affectedCount > 0) {
            res.json({
                status: 200,
                message: '更新用户成功！'
            });
        } else {
            res.status(404).json({
                status: 404,
                message: '用户不存在！'
            });
        }
    } catch (err) {
        console.log(err);
        res.status(500).json({
            status: 500,
            message: '更新用户失败',
            error: err.message
        });
    }
};
// 专门添加空闲时间 - 需要登录且是咨询师或管理员
exports.addCounselorFreeTime = async (req, res) => {
    const { counselor_free_time } = req.body;
    const { id } = req.body;

    // 检查权限：只能是咨询师或管理员操作
    const user = await User.findByPk(id);
    if (!user) {
        return res.status(404).json({
            status: 404,
            message: '用户不存在！'
        });
    }
    if (!(user.is_counselor || user.is_admin)) {
        return res.status(403).json({
            status: 403,
            message: '只有咨询师或管理员可以添加空闲时间！'
        });
    }
    if (req.user.id!== user.id) {
        return res.status(403).json({
            status: 403,
            message: '无权操作其他用户的空闲时间！'
        });
    }

    if (counselor_free_time === undefined || counselor_free_time === null) {
        return res.status(400).json({
            status: 400,
            message: '空闲时间不能为空！'
        });
    }

    try {
        let existingFreeTime = user.counselor_free_time || [];
        // 合并新的空闲时间
        existingFreeTime = existingFreeTime.concat(counselor_free_time);

        const [affectedCount] = await User.update(
            { counselor_free_time: existingFreeTime },
            { where: { id } }
        );

        if (affectedCount > 0) {
            res.json({
                status: 200,
                message: '添加空闲时间成功！'
            });
        } else {
            res.status(404).json({
                status: 404,
                message: '用户不存在！'
            });
        }
    } catch (err) {
        console.log(err);
        res.status(500).json({
            status: 500,
            message: '添加空闲时间失败',
            error: err.message
        });
    }
};

// 专门更新空闲时间 - 需要登录且是咨询师或辅导员
exports.updateCounselorFreeTime = async (req, res) => {
    const { counselor_free_time } = req.body;
    const { id } = req.body;
    
    // 检查权限：只能是咨询师或辅导员修改自己的空闲时间
    const user = await User.findByPk(id);
    if (!user) {
        return res.status(404).json({
            status: 404,
            message: '用户不存在！'
        });
    }
    if (!(user.is_counselor || user.is_assistantn)) {
        return res.status(403).json({
            status: 403,
            message: '只有咨询师或辅导员可以修改空闲时间！'
        });
    }
    if (req.user.id!== user.id) {
        return res.status(403).json({
            status: 403,
            message: '无权修改其他用户的空闲时间！'
        });
    }
    
    if (counselor_free_time === undefined || counselor_free_time === null) {
        return res.status(400).json({
            status: 400,
            message: '空闲时间不能为空！'
        });
    }
    
    try {
        const [affectedCount] = await User.update(
            { counselor_free_time },
            { where: { id } }
        );
        
        if (affectedCount > 0) {
            res.json({
                status: 200,
                message: '更新空闲时间成功！'
            });
        } else {
            res.status(404).json({
                status: 404,
                message: '用户不存在！'
            });
        }
    } catch (err) {
        console.log(err);
        res.status(500).json({
            status: 500,
            message: '更新空闲时间失败',
            error: err.message
        });
    }
};

//专门更新自我介绍 - 需要登录
exports.updateIntroduction = async (req, res) => {
    const { introduction } = req.body;
    const { id } = req.body;
    
    // 检查权限：只能修改自己的信息
    if (req.user.id !== parseInt(id)) {
        return res.status(403).json({
            status: 403,
            message: '无权修改其他用户的自我介绍！'
        });
    }
    
    if (introduction === undefined || introduction === null) {
        return res.status(400).json({
            status: 400,
            message: '自我介绍不能为空！'
        });
    }
    
    try {
        const [affectedCount] = await User.update(
            { introduction },
            { where: { id } }
        );
        
        if (affectedCount > 0) {
            res.json({
                status: 200,
                message: '更新自我介绍成功！'
            });
        } else {
            res.status(404).json({
                status: 404,
                message: '用户不存在！'
            });
        }
    } catch (err) {
        console.log(err);
        res.status(500).json({
            status: 500,
            message: '更新自我介绍失败',
            error: err.message
        });
    }
};

// 修改密码 - 需要登录
exports.updatePassword = async (req, res) => {
    const { password, oldPassword } = req.body;
    const { id: userId } = req.user;
    
    try {
        const user = await User.findOne({
            where: { id: userId }
        });

        if (!user) {
            return res.status(404).json({
                status: 404,
                message: '用户不存在！'
            });
        }
        
        if (user.dataValues.password === oldPassword) {
            await User.update({
                password: password
            }, {
                where: { id: userId }
            });
            res.json({
                status: 200,
                message: '修改密码成功！'
            });
        } else {
            res.status(401).json({
                status: 401,
                message: '旧密码错误！'
            });
        }
    } catch (err) {
        console.log(err);
        res.status(500).json({
            status: 500,
            message: '修改密码失败',
            error: err.message
        });
    }
};


// Excel导入用户（包含自我介绍)
exports.uploadXlsxUsers = async (req, res) => {    
    try {
        console.log(req.file); // 打印文件信息
        const workbook = xlsx.readFile(req.file.path);
        const sheetName = workbook.SheetNames[0];
        const data = xlsx.utils.sheet_to_json(workbook.Sheets[sheetName]);
        
        const results = [];
        
        for (const user of data) {
            try {
                const userExist = await User.findOne({
                    where: { username: user.username }
                });
                
                if (userExist) {
                    results.push({
                        username: user.username,
                        status: 'failed',
                        message: '用户名已存在'
                    });
                    continue;
                }
                
                await User.create({
                    username: user.username,
                    password: user.password || 'defaultPassword',
                    name: user.name,
                    phone: user.phone,
                    email: user.email,
                    id_card: user.id_card,
                    avatar: user.avatar,
                    introduction: user.introduction || '',
                    is_counselor: user.is_counselor || false,
                    is_assistantn: user.is_assistantn || false,
                    is_admin: user.is_admin || false,
                    counselor_free_time: user.counselor_free_time || null // 添加对空闲时间的处理
                });
                
                results.push({
                    username: user.username,
                    status: 'success',
                    message: '导入成功'
                });
                
            } catch (error) {
                results.push({
                    username: user.username || '未知',
                    status: 'failed',
                    message: error.message
                });
            }
        }
        
        res.json({
            status: 200,
            message: '用户信息导入完成',
            data: results
        });
    } catch (error) {
        console.log(error);
        res.status(500).json({
            status: 500,
            message: '导入用户失败',
            error: error.message
        });
    }
};